{
 "cells": [
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    ".. _nb_termination:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Termination Criterion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whenever an algorithm is executed, it needs to be decided whether a next iteration should be started. For single-objective algorithms, a naive implementation can consider the relative improvement in the last $n$ generations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Default Termination ('default')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have added recently developed a termination criterion set if no termination is supplied to the `minimize()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "code": "termination/usage_default.py"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "145\n"
     ]
    }
   ],
   "source": [
    "from pymoo.algorithms.nsga2 import NSGA2\n",
    "from pymoo.factory import get_problem\n",
    "from pymoo.optimize import minimize\n",
    "\n",
    "problem = get_problem(\"zdt1\")\n",
    "algorithm = NSGA2(pop_size=100)\n",
    "\n",
    "res = minimize(problem,\n",
    "               algorithm,\n",
    "               pf=False,\n",
    "               seed=2,\n",
    "               verbose=False)\n",
    "\n",
    "print(res.algorithm.n_gen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This allows you to terminated based on a couple of criteria also explained later on this page. \n",
    "Commonly used are the movement in the design space `f_tol` and the convergence in the constraint `cv_tol` and objective space `f_tol`.\n",
    "To provide an upper bound for the algorithm, we recommend supplying a maximum number of generations `n_max_gen` or function evaluations `n_max_evals`.\n",
    "\n",
    "Moreover, it is worth mentioning that tolerance termination is based on a sliding window. Not only the last, but a sequence of the `n_last` generations are used to calculate compare the tolerances with an bound defined by the user."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default for multi-objective problems, the termination will be set to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pymoo.util.termination.default import MultiObjectiveDefaultTermination\n",
    "\n",
    "termination = MultiObjectiveDefaultTermination(\n",
    "    x_tol=1e-8, \n",
    "    cv_tol=1e-6, \n",
    "    f_tol=0.0025, \n",
    "    nth_gen=5, \n",
    "    n_last=30,\n",
    "    n_max_gen=1000,\n",
    "    n_max_evals=100000\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And for single-optimization to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pymoo.util.termination.default import SingleObjectiveDefaultTermination\n",
    "\n",
    "termination = SingleObjectiveDefaultTermination(\n",
    "    x_tol=1e-8, \n",
    "    cv_tol=1e-6, \n",
    "    f_tol=1e-6, \n",
    "    nth_gen=5, \n",
    "    n_last=20,\n",
    "    n_max_gen=1000,\n",
    "    n_max_evals=100000\n",
    ")"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    ".. _nb_n_eval:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Number of Evaluations ('n_eval')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The termination can simply be reached by providing an upper bound for the number of function evaluations. Whenever in an iteration, the number of function evaluations is greater than this upper bound the algorithm terminates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "code": "termination/usage_n_eval.py"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============================================================\n",
      "n_gen |  n_eval |     igd      |      gd      |      hv     \n",
      "============================================================\n",
      "    1 |     100 |  2.083143534 |  2.470275711 |  0.00000E+00\n",
      "    2 |     200 |  2.083143534 |  2.541455861 |  0.00000E+00\n",
      "    3 |     300 |  1.439763149 |  2.254136798 |  0.00000E+00\n"
     ]
    }
   ],
   "source": [
    "from pymoo.algorithms.nsga2 import NSGA2\n",
    "from pymoo.factory import get_problem, get_termination\n",
    "from pymoo.optimize import minimize\n",
    "\n",
    "problem = get_problem(\"zdt3\")\n",
    "algorithm = NSGA2(pop_size=100)\n",
    "termination = get_termination(\"n_eval\", 300)\n",
    "\n",
    "res = minimize(problem,\n",
    "               algorithm,\n",
    "               termination,\n",
    "               pf=problem.pareto_front(),\n",
    "               seed=1,\n",
    "               verbose=True)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    ".. _nb_n_gen:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Number of Generations ('n_gen')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Moreover, the number of generations / iterations can be limited as well. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "code": "termination/usage_n_gen.py"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============================================================\n",
      "n_gen |  n_eval |     igd      |      gd      |      hv     \n",
      "============================================================\n",
      "    1 |     100 |  2.083143534 |  2.470275711 |  0.00000E+00\n",
      "    2 |     200 |  2.083143534 |  2.541455861 |  0.00000E+00\n",
      "    3 |     300 |  1.439763149 |  2.254136798 |  0.00000E+00\n",
      "    4 |     400 |  1.322049373 |  2.211177241 |  0.00000E+00\n",
      "    5 |     500 |  1.322049373 |  2.049932619 |  0.00000E+00\n",
      "    6 |     600 |  1.322049373 |  2.252465552 |  0.00000E+00\n",
      "    7 |     700 |  1.174569841 |  2.093527386 |  0.00000E+00\n",
      "    8 |     800 |  1.174569841 |  1.930483702 |  0.00000E+00\n",
      "    9 |     900 |  1.023102225 |  1.607960322 |  0.003340339\n",
      "   10 |    1000 |  0.980982415 |  1.352084952 |  0.003340339\n"
     ]
    }
   ],
   "source": [
    "from pymoo.algorithms.nsga2 import NSGA2\n",
    "from pymoo.factory import get_problem, get_termination\n",
    "from pymoo.optimize import minimize\n",
    "\n",
    "problem = get_problem(\"zdt3\")\n",
    "algorithm = NSGA2(pop_size=100)\n",
    "termination = get_termination(\"n_gen\", 10)\n",
    "\n",
    "res = minimize(problem,\n",
    "               algorithm,\n",
    "               termination,\n",
    "               pf=problem.pareto_front(),\n",
    "               seed=1,\n",
    "               verbose=True)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    ".. _nb_time:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Based on Time ('time')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The termination can also be based on the time of the algorithm to be executed. For instance, to run an algorithm for 3 seconds the termination can be defined by `get_termination(\"time\", \"00:00:03\")` or for 1 hour and 30 minutes by `get_termination(\"time\", \"01:30:00\")`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "code": "termination/usage_time.py"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "392\n"
     ]
    }
   ],
   "source": [
    "from pymoo.algorithms.nsga2 import NSGA2\n",
    "from pymoo.factory import get_problem, get_termination\n",
    "from pymoo.optimize import minimize\n",
    "\n",
    "problem = get_problem(\"zdt3\")\n",
    "algorithm = NSGA2(pop_size=100)\n",
    "termination = get_termination(\"time\", \"00:00:03\")\n",
    "\n",
    "res = minimize(problem,\n",
    "               algorithm,\n",
    "               termination,\n",
    "               pf=problem.pareto_front(),\n",
    "               seed=1,\n",
    "               verbose=False)\n",
    "\n",
    "print(res.algorithm.n_gen)\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    ".. _nb_xtol:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Design Space Tolerance ('x_tol')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, we can track the change in the design space. For a parameter explanation, please have a look at 'ftol'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "code": "termination/usage_xtol.py"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "167\n"
     ]
    }
   ],
   "source": [
    "from pymoo.algorithms.nsga2 import NSGA2\n",
    "from pymoo.factory import get_problem\n",
    "from pymoo.optimize import minimize\n",
    "from pymoo.util.termination.x_tol import DesignSpaceToleranceTermination\n",
    "\n",
    "problem = get_problem(\"zdt3\")\n",
    "algorithm = NSGA2(pop_size=100)\n",
    "termination = DesignSpaceToleranceTermination(tol=0.0025, n_last=20)\n",
    "\n",
    "res = minimize(problem,\n",
    "               algorithm,\n",
    "               termination,\n",
    "               pf=problem.pareto_front(),\n",
    "               seed=1,\n",
    "               verbose=False)\n",
    "\n",
    "print(res.algorithm.n_gen)\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    ".. _nb_ftol:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objective Space Tolerance ('f_tol')\n",
    "\n",
    "The most interesting stopping criterion is to use objective space change to decide whether to terminate the algorithm. Here, we mostly use a simple and efficient procedure to determine whether to stop or not. We aim to improve it further in the future. If somebody is interested in collaborating, please let us know.\n",
    "\n",
    "The parameters of our implementation are:\n",
    "\n",
    "**tol**: What is the tolerance in the objective space on average. If the value is below this bound, we terminate.\n",
    "\n",
    "**n_last**: To make the criterion more robust, we consider the last $n$ generations and take the maximum. This considers the worst case in a window.\n",
    "\n",
    "**n_max_gen**: As a fallback, the generation number can be used. For some problems, the termination criterion might not be reached; however, an upper bound for generations can be defined to stop in that case.\n",
    "\n",
    "**nth_gen**: Defines whenever the termination criterion is calculated by default, every 10th generation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "code": "termination/usage_ftol.py"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generations 165\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<pymoo.visualization.scatter.Scatter at 0x7fafdf8b4dd0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 387,
       "width": 513
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pymoo.algorithms.nsga2 import NSGA2\n",
    "from pymoo.factory import get_problem\n",
    "from pymoo.optimize import minimize\n",
    "from pymoo.util.termination.f_tol import MultiObjectiveSpaceToleranceTermination\n",
    "from pymoo.visualization.scatter import Scatter\n",
    "\n",
    "problem = get_problem(\"zdt3\")\n",
    "algorithm = NSGA2(pop_size=100)\n",
    "termination = MultiObjectiveSpaceToleranceTermination(tol=0.0025,\n",
    "                                                      n_last=30,\n",
    "                                                      nth_gen=5,\n",
    "                                                      n_max_gen=None,\n",
    "                                                      n_max_evals=None)\n",
    "\n",
    "res = minimize(problem,\n",
    "               algorithm,\n",
    "               termination,\n",
    "               pf=True,\n",
    "               seed=1,\n",
    "               verbose=False)\n",
    "\n",
    "print(\"Generations\", res.algorithm.n_gen)\n",
    "plot = Scatter(title=\"ZDT3\")\n",
    "plot.add(problem.pareto_front(use_cache=False, flatten=False), plot_type=\"line\", color=\"black\")\n",
    "plot.add(res.F, color=\"red\", alpha=0.8, s=20)\n",
    "plot.show()\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
